home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_support.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  9.7 KB  |  335 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Supporting definitions for the Python regression tests.'''
  5. if __name__ != 'test.test_support':
  6.     raise ImportError, 'test_support must be imported from the test package'
  7.  
  8. import sys
  9.  
  10. class Error(Exception):
  11.     '''Base class for regression test exceptions.'''
  12.     pass
  13.  
  14.  
  15. class TestFailed(Error):
  16.     '''Test failed.'''
  17.     pass
  18.  
  19.  
  20. class TestSkipped(Error):
  21.     """Test skipped.
  22.  
  23.     This can be raised to indicate that a test was deliberatly
  24.     skipped, but not because a feature wasn't available.  For
  25.     example, if some resource can't be used, such as the network
  26.     appears to be unavailable, this should be raised instead of
  27.     TestFailed.
  28.     """
  29.     pass
  30.  
  31.  
  32. class ResourceDenied(TestSkipped):
  33.     '''Test skipped because it requested a disallowed resource.
  34.  
  35.     This is raised when a test calls requires() for a resource that
  36.     has not be enabled.  It is used to distinguish between expected
  37.     and unexpected skips.
  38.     '''
  39.     pass
  40.  
  41. verbose = 1
  42. use_resources = None
  43. _original_stdout = None
  44.  
  45. def record_original_stdout(stdout):
  46.     global _original_stdout
  47.     _original_stdout = stdout
  48.  
  49.  
  50. def get_original_stdout():
  51.     if not _original_stdout:
  52.         pass
  53.     return sys.stdout
  54.  
  55.  
  56. def unload(name):
  57.     
  58.     try:
  59.         del sys.modules[name]
  60.     except KeyError:
  61.         pass
  62.  
  63.  
  64.  
  65. def forget(modname):
  66.     '''"Forget" a module was ever imported by removing it from sys.modules and
  67.     deleting any .pyc and .pyo files.'''
  68.     unload(modname)
  69.     import os
  70.     for dirname in sys.path:
  71.         
  72.         try:
  73.             os.unlink(os.path.join(dirname, modname + os.extsep + 'pyc'))
  74.         except os.error:
  75.             pass
  76.  
  77.         
  78.         try:
  79.             os.unlink(os.path.join(dirname, modname + os.extsep + 'pyo'))
  80.         continue
  81.         except os.error:
  82.             continue
  83.         
  84.  
  85.     
  86.  
  87.  
  88. def is_resource_enabled(resource):
  89.     '''Test whether a resource is enabled.  Known resources are set by
  90.     regrtest.py.'''
  91.     if use_resources is not None:
  92.         pass
  93.     return resource in use_resources
  94.  
  95.  
  96. def requires(resource, msg = None):
  97.     """Raise ResourceDenied if the specified resource is not available.
  98.  
  99.     If the caller's module is __main__ then automatically return True.  The
  100.     possibility of False being returned occurs when regrtest.py is executing."""
  101.     if sys._getframe().f_back.f_globals.get('__name__') == '__main__':
  102.         return None
  103.     
  104.     if not is_resource_enabled(resource):
  105.         if msg is None:
  106.             msg = "Use of the `%s' resource not enabled" % resource
  107.         
  108.         raise ResourceDenied(msg)
  109.     
  110.  
  111. FUZZ = 9.9999999999999995e-07
  112.  
  113. def fcmp(x, y):
  114.     if type(x) == type(0.0) or type(y) == type(0.0):
  115.         
  116.         try:
  117.             (x, y) = coerce(x, y)
  118.             fuzz = (abs(x) + abs(y)) * FUZZ
  119.             if abs(x - y) <= fuzz:
  120.                 return 0
  121.  
  122.     elif type(x) == type(y) and type(x) in (type(()), type([])):
  123.         for i in range(min(len(x), len(y))):
  124.             outcome = fcmp(x[i], y[i])
  125.             if outcome != 0:
  126.                 return outcome
  127.                 continue
  128.         
  129.         return cmp(len(x), len(y))
  130.     
  131.     return cmp(x, y)
  132.  
  133.  
  134. try:
  135.     unicode
  136.     have_unicode = 1
  137. except NameError:
  138.     have_unicode = 0
  139.  
  140. is_jython = sys.platform.startswith('java')
  141. import os
  142. if os.name == 'java':
  143.     TESTFN = '$test'
  144. elif os.name == 'riscos':
  145.     TESTFN = 'testfile'
  146. else:
  147.     TESTFN = '@test'
  148.     if have_unicode:
  149.         if isinstance('', unicode):
  150.             TESTFN_UNICODE = '@test-\xe0\xf2'
  151.         else:
  152.             TESTFN_UNICODE = unicode('@test-\xe0\xf2', 'latin-1')
  153.         TESTFN_ENCODING = sys.getfilesystemencoding()
  154.         if not hasattr(sys, 'getwindowsversion') or sys.getwindowsversion()[3] < 2:
  155.             TESTFN_UNICODE_UNENCODEABLE = None
  156.         else:
  157.             TESTFN_UNICODE_UNENCODEABLE = eval('u"@test-\\u5171\\u6709\\u3055\\u308c\\u308b"')
  158.             
  159.             try:
  160.                 TESTFN_UNICODE_UNENCODEABLE.encode('Latin1')
  161.             except UnicodeEncodeError:
  162.                 pass
  163.  
  164.             print 'WARNING: The filename %r CAN be encoded by the filesystem.  Unicode filename tests may not be effective' % TESTFN_UNICODE_UNENCODEABLE
  165.     
  166. fp = None
  167.  
  168. try:
  169.     fp = open(TESTFN, 'w+')
  170. except IOError:
  171.     TMP_TESTFN = os.path.join('/tmp', TESTFN)
  172.     
  173.     try:
  174.         fp = open(TMP_TESTFN, 'w+')
  175.         TESTFN = TMP_TESTFN
  176.         del TMP_TESTFN
  177.     except IOError:
  178.         print 'WARNING: tests will fail, unable to write to: %s or %s' % (TESTFN, TMP_TESTFN)
  179.     except:
  180.         None<EXCEPTION MATCH>IOError
  181.     
  182.  
  183.     None<EXCEPTION MATCH>IOError
  184.  
  185. if fp is not None:
  186.     fp.close()
  187.     
  188.     try:
  189.         os.unlink(TESTFN)
  190.  
  191.  
  192. del os
  193. del fp
  194. from os import unlink
  195.  
  196. def findfile(file, here = __file__):
  197.     '''Try to find a file on sys.path and the working directory.  If it is not
  198.     found the argument passed to the function is returned (this does not
  199.     necessarily signal failure; could still be the legitimate path).'''
  200.     import os
  201.     if os.path.isabs(file):
  202.         return file
  203.     
  204.     path = sys.path
  205.     path = [
  206.         os.path.dirname(here)] + path
  207.     for dn in path:
  208.         fn = os.path.join(dn, file)
  209.         if os.path.exists(fn):
  210.             return fn
  211.             continue
  212.     
  213.     return file
  214.  
  215.  
  216. def verify(condition, reason = 'test failed'):
  217.     '''Verify that condition is true. If not, raise TestFailed.
  218.  
  219.        The optional argument reason can be given to provide
  220.        a better error text.
  221.     '''
  222.     if not condition:
  223.         raise TestFailed(reason)
  224.     
  225.  
  226.  
  227. def vereq(a, b):
  228.     '''Raise TestFailed if a == b is false.
  229.  
  230.     This is better than verify(a == b) because, in case of failure, the
  231.     error message incorporates repr(a) and repr(b) so you can see the
  232.     inputs.
  233.  
  234.     Note that "not (a == b)" isn\'t necessarily the same as "a != b"; the
  235.     former is tested.
  236.     '''
  237.     if not a == b:
  238.         raise TestFailed, '%r == %r' % (a, b)
  239.     
  240.  
  241.  
  242. def sortdict(dict):
  243.     '''Like repr(dict), but in sorted order.'''
  244.     items = dict.items()
  245.     items.sort()
  246.     reprpairs = [ '%r: %r' % pair for pair in items ]
  247.     withcommas = ', '.join(reprpairs)
  248.     return '{%s}' % withcommas
  249.  
  250.  
  251. def check_syntax(statement):
  252.     
  253.     try:
  254.         compile(statement, '<string>', 'exec')
  255.     except SyntaxError:
  256.         pass
  257.  
  258.     print 'Missing SyntaxError: "%s"' % statement
  259.  
  260. import unittest
  261.  
  262. class BasicTestRunner:
  263.     
  264.     def run(self, test):
  265.         result = unittest.TestResult()
  266.         test(result)
  267.         return result
  268.  
  269.  
  270.  
  271. def run_suite(suite, testclass = None):
  272.     '''Run tests from a unittest.TestSuite-derived class.'''
  273.     if verbose:
  274.         runner = unittest.TextTestRunner(sys.stdout, verbosity = 2)
  275.     else:
  276.         runner = BasicTestRunner()
  277.     result = runner.run(suite)
  278.     if not result.wasSuccessful():
  279.         if len(result.errors) == 1 and not (result.failures):
  280.             err = result.errors[0][1]
  281.         elif len(result.failures) == 1 and not (result.errors):
  282.             err = result.failures[0][1]
  283.         elif testclass is None:
  284.             msg = 'errors occurred; run in verbose mode for details'
  285.         else:
  286.             msg = 'errors occurred in %s.%s' % (testclass.__module__, testclass.__name__)
  287.         raise TestFailed(msg)
  288.         raise TestFailed(err)
  289.     
  290.  
  291.  
  292. def run_unittest(*classes):
  293.     '''Run tests from unittest.TestCase-derived classes.'''
  294.     suite = unittest.TestSuite()
  295.     for cls in classes:
  296.         if isinstance(cls, (unittest.TestSuite, unittest.TestCase)):
  297.             suite.addTest(cls)
  298.             continue
  299.         suite.addTest(unittest.makeSuite(cls))
  300.     
  301.     if len(classes) == 1:
  302.         testclass = classes[0]
  303.     else:
  304.         testclass = None
  305.     run_suite(suite, testclass)
  306.  
  307.  
  308. def run_doctest(module, verbosity = None):
  309.     """Run doctest on the given module.  Return (#failures, #tests).
  310.  
  311.     If optional argument verbosity is not specified (or is None), pass
  312.     test_support's belief about verbosity on to doctest.  Else doctest's
  313.     usual behavior is used (it searches sys.argv for -v).
  314.     """
  315.     import doctest
  316.     if verbosity is None:
  317.         verbosity = verbose
  318.     else:
  319.         verbosity = None
  320.     save_stdout = sys.stdout
  321.     sys.stdout = get_original_stdout()
  322.     
  323.     try:
  324.         (f, t) = doctest.testmod(module, verbose = verbosity)
  325.         if f:
  326.             raise TestFailed('%d of %d doctests failed' % (f, t))
  327.     finally:
  328.         sys.stdout = save_stdout
  329.  
  330.     if verbose:
  331.         print 'doctest (%s) ... %d tests with zero failures' % (module.__name__, t)
  332.     
  333.     return (f, t)
  334.  
  335.